package com.ctl.juc.queue;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;

/**
 * 是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。
 * SynchronousQueue 可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线
 * 程。队列本身并不存储任何元素，非常适合于传递性场景,比如在一个线程中使用的数据，传递给
 * 另外一个线程使用， SynchronousQueue 的吞吐量高于 LinkedBlockingQueue 和
 * ArrayBlockingQueue。
 */
public class SynchronousQueueTest {
    private volatile static  int i=0;
    private volatile static  int j=0;
    private volatile static  int m=1111;
    public static void main(String[] args) {
        SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue();
        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                try {
                    synchronousQueue.put(i++);
                    System.out.println(synchronousQueue.size());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();
        new Thread(()->{
            for (int k = 0; k <100 ; k++) {
                try {
                    synchronousQueue.put(j--);
                    System.out.println(synchronousQueue.size());

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();

//        new Thread(()->{
//            for (int k = 0; k <100 ; k++) {
//                try {
//                    Integer i=synchronousQueue.take();
//                    System.out.println(i);
//                } catch (InterruptedException e) {
//
//                }
//            }
//        }).start();
//
//        for (int k = 0; k <100 ; k++) {
//            try {
//                Integer i=synchronousQueue.take();
//                System.out.println(i);
//            } catch (InterruptedException e) {
//
//            }
//        }
    }
}
